class linkedListNode {
    constructor(value) {
        this.value = value ? value : undefined;
        this.next = null;
    }
}


class LinkedList {
    constructor() {
        this._size = 0;
        this.head = new linkedListNode()
    }

    insert(value, position) {
        if (position < 0 || position > this._size) {
            return false;
        }

        // 批注：
        // 你 linkedListNode 已经实现了构造，可以直接 let insertListNode = new linkedListNode(value) 来创建新节点
        //创建新节点并初始化值
        let insertListNode = new linkedListNode();
        insertListNode.value = value;

        // 批注：
        // 用 for 循环来做，找到第 position 的前一个节点，只需以 head 为首节点，循环 position 次
        //找到要插入的原节点及原节点前一个节点
        let flag = 0;
        let formerNode = this.head
        while (flag !== position) {
            formerNode = formerNode.next
            flag += 1;
        }
        insertListNode.next = formerNode.next;
        formerNode.next = insertListNode;
        this._size += 1;
        return true;
    }

    delete(position) {
        // 批注：见 BasicArray 的批注
        if (position < 0 || position > this._size - 1) {
            return false;
        }
        // 批注：
        // 用 for 循环来做，找到第 position 的前一个节点，只需以 head 为首节点，循环 position 次
        // 并且有两个函数用到了相同的逻辑，可以考虑封装一个函数，专门返回指定位置的节点
        let flag = 0;
        let formerNode = new linkedListNode();
        formerNode = this.head;
        while (flag !== position) {
            formerNode = formerNode.next
            flag += 1;
        }

        formerNode.next = formerNode.next.next;
        // formerNode.next.next = null; //??
        this._size -= 1;
        return true;
    }

    get(position) {
        if (position < 0 || position > this._size - 1) {
            return undefined;
        }
        let flag = 0;
        let resultNode = this.head;
        while (flag !== position + 1) {
            resultNode = resultNode.next;
            flag += 1;
        }
        return resultNode.value;
    }

    toArray() {
        let resultArr = [];
        // 批注：这里可以用 for 循环来做，只需以 head->next 为首节点，直到 tempNode 为 null为止
        let tempNode = this.head.next;
        for (let i = 0; i < this._size; i++) {
            resultArr.push(tempNode.value)
            tempNode = tempNode.next;
        }
    }

    size() {
        return this._size;
    }

    // 批注：逻辑不对
    indexOf(value) {
        let tempNode = this.head.next;
        while (tempNode.next) {
            if (tempNode.value = value) {
                return value;
            }
            tempNode = tempNode.next;
        }
        return -1;
    }
}

let list = new LinkedList();
list.insert(1, 0);
console.log(list.indexOf(1))

export default LinkedList;